<html>

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> 
  <link rel="stylesheet" title="Default" href="http://acm.math.spbu.ru/~sk1/colorer/my.css">

  <script src="http://acm.math.spbu.ru/~sk1/colorer/highlight.js"></script>
  <script src="http://acm.math.spbu.ru/~sk1/colorer/cpp.js"></script>
  <script>hljs.initHighlightingOnLoad();</script>
</head>

<body>

<pre><code>
#include &lt;cmath&gt;
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;

#include &lt;algorithm&gt;

using namespace std;

#define forn(i, n) for (int i = 0; i &lt; (int)(n); i++)

typedef long long ll;
typedef double dbl;

const int maxn = (int)4e5 + 9;
const dbl eps = 1e-12;

dbl sqr( dbl x ) { return x * x; }

struct pnt
{
  int x, y;

  pnt() { }
  pnt( int _x, int _y ) : x(_x), y(_y) { }

  pnt operator + ( pnt p ) { return pnt(x + p.x, y + p.y); } 
  pnt operator - ( pnt p ) { return pnt(x - p.x, y - p.y); } 
  pnt operator - () { return pnt(-x, -y); } 

  ll operator * ( pnt p ) { return (ll)x * p.y - (ll)y * p.x; } 
  ll operator ^ ( pnt p ) { return (ll)x * p.x + (ll)y * p.y; } 

  pnt ort() { return pnt(-y, x); }

  dbl ang() { return atan2(y, x); }
  ll d2() { return x * x + y * y; }
};

pnt st, v, p[maxn];
int n, sp, ss[maxn], ind[maxn], no[maxn];
int cnt[maxn];

int k = 0, a[maxn], b[maxn];
dbl ang[maxn];

void No()
{
  puts("Impossible");
  exit(0);
}

bool vless( int i, int j )
{
  #define F(i) ((p[i] - st) ^ v)
  return F(i) &lt; F(j);
}

bool pless( pnt a, pnt b )
{
  if (a * b != 0)
    return a * b &gt; 0;
  return a.d2() &lt; b.d2();
}

bool pless2( int a, int b )
{
  return pless(p[a], p[b]);
}

pnt Norm( int k )
{
  return (p[a[k]] - p[b[k]]).ort();
}

void AddPlane( int i, int j )
{
  a[k] = i, b[k] = j, ind[k] = k;
  ang[k] = Norm(k).ang();
  k++;
}

bool angLess( int i, int j )
{
  return ang[i] &lt; ang[j];
}

void Unique()
{
  int i = 0, k2 = 0;
  while (i &lt; k)
  {
    int ma = ind[i], st = i;
    pnt no = Norm(ma);

    for (i++; i &lt; k && fabs(ang[ind[st]] - ang[ind[i]]) &lt; eps; i++)
      if ((no ^ p[a[ma]]) &lt; (no ^ p[a[ind[i]]]))
        ma = ind[i];
    ind[k2++] = ma;
  }
  k = k2;
}

dbl xx, yy, tmp;

#define BUILD(a1, b1, c1, i) \
  dbl a1 = Norm(i).x; \
  dbl b1 = Norm(i).y; \
  tmp = sqrt(a1 * a1 + b1 * b1); \
  a1 /= tmp, b1 /= tmp; \
  dbl c1 = -(a1 * p[a[i]].x + b1 * p[a[i]].y);

void FindPoint( int i, int j, dbl step = 0.0 )
{
  BUILD(a1, b1, c1, i);
  BUILD(a2, b2, c2, j);

  xx = -(c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1);
  yy = (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);

  dbl no = sqrt(sqr(a1 + a2) + sqr(b1 + b2));
  xx += (a1 + a2) * step / no;
  yy += (b1 + b2) * step / no;
}

void TryShiftPoint( int i, int j, dbl step )
{
  FindPoint(i, j, step);

  forn(i, k)
  {
    BUILD(a1, b1, c1, ind[i]);
    if (a1 * xx + b1 * yy + c1 &lt; eps)
      return;
  }

  puts("Possible");
  printf("%.20lf %.20lf\n", (double)xx, (double)yy);
  exit(0);
}

void PushPlaneIntoStack( int i )
{
  while (sp &gt;= 2 && ang[i] - ang[ss[sp - 2]] + eps &lt; M_PI)
  {
    FindPoint(i, ss[sp - 2]);

    BUILD(a1, b1, c1, ss[sp - 1]);
    if ((a1 * xx + b1 * yy + c1) &lt; -eps)
      break;

    sp--;
  }
  ss[sp++] = i;
}

int main()
{
  freopen("forest.in", "r", stdin);
  freopen("forest.out", "w", stdout);

  scanf("%d", &n);
  forn(i, n)
    scanf("%d%d", &p[i].x, &p[i].y);
  p[n] = p[0];

  // all points on the same line
  int good = 0;
  forn(i, n)
    if ((p[i] - p[0]) * (p[1] - p[0]) != 0)
      good = 1;
  if (!good)
  {
    st = p[0], v = p[1] - p[0];
    forn(i, n)
      ind[i] = i;
    sort(ind, ind + n, vless);
    if (ind[0] != 0)
      reverse(ind, ind + n), v = -v;
    forn(i, n)
      if (ind[i] != i)
        No();

    pnt res = p[0] + v.ort();
    printf("Possible\n%d %d\n", res.x, res.y);
    return 0;
  }

  // Find convex hull. We already know, it's nondegenerate.
  int mi = 0;
  forn(i, n)
    if (p[i].y &lt; p[mi].y || (p[i].y == p[mi].y && p[i].x &gt; p[mi].x))
      mi = i;
  forn(i, n)
    ind[i] = i;
  swap(ind[0], ind[mi]);

  st = p[ind[0]];
  forn(i, n)
    p[i] = p[i] - st;
  sort(ind + 1, ind + n, pless2);

  forn(i, n)
  {
    while (sp &gt;= 2 && !pless(p[ss[sp - 1]] - p[ss[sp - 2]], p[ind[i]] - p[ss[sp - 1]]))
      sp--;
    ss[sp++] = ind[i];
  }
  forn(i, n)
    p[i] = p[i] + st;
  ss[sp] = ss[0];

  // Find set of planes
  forn(i, sp)
    AddPlane(max(ss[i], ss[i + 1]), min(ss[i], ss[i + 1]));
  forn(i, n - 1)
    AddPlane(i + 1, i);
  sort(ind, ind + k, angLess);
  
  int oldK = k;
  Unique();

  forn(i, oldK)
    no[i] = i;
  forn(i, k)
  {
    int j = oldK + i, x = ind[i];
    ang[j] = ang[x] + 2 * M_PI;
    a[j] = a[x];
    b[j] = b[x];
    ind[i + k] = j, no[j] = x;
  }

  dbl dif;
  sp = 0;
  forn(i, k)
    if ((dif = ang[ind[i + 1]] - ang[ind[i]]) &gt; M_PI - eps)
    {
      forn(j, k)
        PushPlaneIntoStack(ind[i + j + 1]);
      TryShiftPoint(ss[0], ss[1], 1e-5);
      No();
    }

  forn(i, 2 * k)
    PushPlaneIntoStack(ind[i]);
  forn(t, sp)
    if (++cnt[no[ss[t]]] &gt; 1)
    {
      TryShiftPoint(ss[t], ss[t - 1], 1e-5);
      break;
    }

  No();
  return 0;
}

</code></pre>

</body>
</html>

<font style="visibility:hidden">
